'use strict';

/**
 * 登录账户逻辑控制器
 */
const Code = require('../common/error_code');
const Cons = require('../common/constants');
const accountModel = require('../models/account.model');
const token = require('../utils/token');
const Util = require('../utils/hobot_util');
const globalConfig = require('../../config/global_config');

/**
 * 管理员登录
 */
async function login(ctx) {
    const params = ctx.request.query;
    // 校验参数
    if (!params.user_acc || !params.user_pwd) {
        return ctx.error(Code.RET_ADMIN_LOGIN_ERR_PARAM);
    }

    const acc = await accountModel.findOne({ _id: params.user_acc, u_pw: params.user_pwd });
    if (acc) {
        ctx.success(Code.RET_ADMIN_LOGIN_OK,
            {
                user_acc: acc._id, user_name: acc.u_nm, user_role: acc.u_ro,
                token: token.generateToken({ user_id: acc._id, user_role: acc.u_ro })
            });
    } else {
        ctx.error(Code.RET_ADMIN_LOGIN_ERR_AUTH);
    }
}

/**
 * 修改密码
 */
async function password(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.user_acc || !params.pwd_old || !params.pwd_new) {
        return ctx.error(Code.RET_ADMIN_PASSWORD_ERR_PARAM);
    }

    const acc = await accountModel.findOne({ _id: params.user_acc, u_pw: params.pwd_old });
    if (acc) {
        await accountModel.update({ _id: params.user_acc }, { u_pw: params.pwd_new });
        ctx.success(Code.RET_ADMIN_PASSWORD_OK);
    } else {
        ctx.error(Code.RET_ADMIN_PASSWORD_ERR_AUTH);
    }
}

/**
 * 重置密码
 */
async function reset_pwd(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.user_acc || !params.user_pwd) {
        return ctx.error(Code.RET_ADMIN_RESET_PWD_ERR_PARAM);
    }

    const acc = await accountModel.findOne({ _id: params.user_acc });
    if (!acc) {
        return ctx.error(Code.RET_ADMIN_RESET_PWD_ERR_NOT_EXIST);
    }

    await accountModel.update({ _id: params.user_acc }, { u_pw: params.user_pwd });
    ctx.success(Code.RET_ADMIN_RESET_PWD_OK);
}

/**
 * 查询用户
 */
async function query(ctx) {
    // 超级管理员排除在外
    const acc = await accountModel.find({ _id: { $ne: 'admin' } });
    let rst = [];
    if (acc) {
        acc.forEach(function (item) {
            rst.push({
                acc_id: item._id,
                acc_name: item.u_nm,
                acc_email: item.u_em,
                acc_role: item.u_ro
            });
        });
    }
    ctx.success(Code.RET_ADMIN_QUERY_OK, rst);
}

/**
 * 添加用户
 */
async function add(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.acc_id || !params.acc_name || !params.acc_role || !params.acc_pwd) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM);
    }
    if (params.acc_id.length > 32) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM_ID_TOO_LONG);
    }
    if (!Util.checkUserId(params.acc_id)) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM_ID);
    }
    if (params.acc_email && !Util.isEmail(params.acc_email)) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM_EMAIL)
    }
    // 只能添加人事专员和行政专员角色
    if (params.acc_role && params.acc_role != Cons.ROLE_HR && params.acc_role != Cons.ROLE_OPERATION) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM);
    }

    // 判断账号是否已存在
    const has = await accountModel.findOne({ _id: params.acc_id });
    if (has) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_EXIST);
    }

    let model = {
        _id: params.acc_id,
        u_nm: params.acc_name,
        u_ro: params.acc_role,
        u_pw: params.acc_pwd
    };
    if (params.acc_email) {
        model.u_em = params.acc_email;
    }
    await accountModel.create(model);
    ctx.success(Code.RET_ADMIN_ADD_OK);
}

/**
 * 修改用户
 */
async function update(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.acc_id) {
        return ctx.error(Code.RET_ADMIN_UPDATE_ERR_PARAM);
    }
    if (params.acc_email && !Util.isEmail(params.acc_email)) {
        return ctx.error(Code.RET_ADMIN_UPDATE_ERR_PARAM_EMAIL)
    }
    // 人事专员和行政专员角色
    if (params.acc_role && params.acc_role != Cons.ROLE_HR && params.acc_role != Cons.ROLE_OPERATION) {
        return ctx.error(Code.RET_ADMIN_ADD_ERR_PARAM);
    }
    const acc = await accountModel.findOne({ _id: params.acc_id });
    if (!acc) {
        return ctx.error(Code.RET_ADMIN_UPDATE_ERR_PARAM);
    }

    let upd = { u_em: params.acc_email };
    if (params.acc_role) {
        upd.u_ro = Number(params.acc_role);
    }
    if (params.acc_name) {
        upd.u_nm = params.acc_name;
    }
    await accountModel.update({ _id: params.acc_id }, upd);
    ctx.success(Code.RET_ADMIN_UPDATE_OK);
}

/**
 * 删除用户
 */
async function del(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.acc_id) {
        return ctx.error(Code.RET_ADMIN_DELETE_ERR_PARAM);
    }

    await accountModel.remove({ _id: params.acc_id });
    ctx.success(Code.RET_ADMIN_DELETE_OK);
}

async function init() {
    const acc = await accountModel.findOne({ _id: globalConfig.account.id });
    if (!acc) {
        let model = {
            _id: globalConfig.account.id,
            u_nm: "admin",
            u_ro: Cons.ROLE_ADMIN,
            u_pw: globalConfig.account.pwd
        };
        accountModel.create(model)
    }
}


exports.init = init;
// 管理员登录
exports.login = login;
// 修改密码
exports.password = password;
// 重置密码
exports.reset_pwd = reset_pwd;
// 查询用户
exports.query = query;
// 添加用户
exports.add = add;
// 修改用户
exports.update = update;
// 删除用户
exports.delete = del;
